home *** CD-ROM | disk | FTP | other *** search
/ MacFormat 1995 March / macformat-022.iso / Shareware City / Developers / ANSI folder / INTO Libraries ƒ / MacOS 68K ƒ / MacOS Sources ƒ / MPW Glue.c < prev   
Encoding:
C/C++ Source or Header  |  1994-09-27  |  16.3 KB  |  676 lines  |  [TEXT/MMCC]
  1. #include <MacHeaders68K>
  2.  
  3. #pragma pointers_in_D0        //    required for c-style toolbox glue function: c2pstr and p2cstr
  4.                             //    the inverse operation (pointers_in_A0) is performed at the end ...
  5.  
  6. //    Generate this as near code calls ...
  7. #pragma near_code
  8.  
  9. // glue code for missing old Pascal functions ...
  10. extern pascal void (UprString)(Str255 theString,Boolean diacSens);
  11. pascal void (UpperString)(Str255 theString,Boolean diacSens)
  12. {
  13.     (UprString)(theString,diacSens);
  14. }
  15.  
  16. // glue code for 'C' style toolbox calls ...
  17.  
  18. OSErr fsrename(char *oldName,short vRefNum,char *newName)
  19. {
  20.     Rename( c2pstr(oldName),  vRefNum,  c2pstr(newName));
  21.     p2cstr((unsigned char *)oldName); p2cstr((unsigned char *)newName);
  22. }
  23.  
  24. char *p2cstr(StringPtr aStr) 
  25. {
  26.     return (char *) P2CStr(aStr);
  27. }
  28.  
  29. StringPtr c2pstr(char *aStr)
  30. {
  31.      return C2PStr(aStr);
  32. }
  33.  
  34. ControlHandle newcontrol(WindowPtr theWindow,const Rect *boundsRect,char *title,
  35.     Boolean visible,short value,short min,short max,short procID,long refCon) 
  36. {
  37.     ControlHandle h = 
  38.     NewControl(theWindow,boundsRect,c2pstr(title),visible,value,min,max,procID,refCon);
  39.     p2cstr((StringPtr) title);
  40.     return h;
  41. }
  42.  
  43. void setcontroltitle(ControlHandle theControl, char *title)
  44. {
  45.     SetControlTitle(theControl,c2pstr(title));
  46.     p2cstr((StringPtr) title);
  47. }
  48.  
  49. void getcontroltitle(ControlHandle theControl, char *title)
  50. {
  51.     GetControlTitle(theControl,(StringPtr) title);
  52.     p2cstr((StringPtr) title);
  53. }
  54.  
  55. short testcontrol(ControlHandle theControl, Point *thePt)
  56. {
  57.     return TestControl(theControl,*thePt);
  58. }
  59.  
  60. short findcontrol(Point *thePoint, WindowPtr theWindow, ControlHandle *theControl)
  61. {
  62.     return FindControl(*thePoint,theWindow,theControl);
  63. }
  64.  
  65. short trackcontrol(ControlHandle theControl, Point *thePoint, ControlActionUPP actionProc)
  66. {
  67.     return TrackControl(theControl, *thePoint, actionProc);
  68. }
  69.  
  70. void dragcontrol(ControlHandle theControl, Point *startPt, const Rect *limitRect, const Rect *slopRect, short axis)
  71. {
  72.     DragControl(theControl,*startPt, limitRect, slopRect, axis);
  73. }
  74.  
  75. short opendeskacc(char *deskAccName)
  76. {
  77.     short s = OpenDeskAcc(c2pstr(deskAccName));
  78.     p2cstr((StringPtr) deskAccName);
  79.     return s;
  80. }
  81.  
  82. OSErr opendriver(char *driverName, short *refNum)
  83. {
  84.     OSErr err = OpenDriver(c2pstr(driverName),refNum);
  85.     p2cstr((StringPtr) driverName);
  86.     return err;
  87. }
  88.  
  89. DialogPtr newdialog(void *wStorage, const Rect *boundsRect, char *title, Boolean visible, short procID, WindowPtr behind, Boolean goAwayFlag, long refCon, Handle itmLstHndl)
  90. {
  91.     DialogPtr dp = NewDialog(wStorage,boundsRect,c2pstr(title),visible,procID,behind,goAwayFlag,refCon,itmLstHndl);
  92.     
  93.     p2cstr((StringPtr) title);
  94.     return dp;
  95. }
  96.  
  97. DialogPtr newcolordialog(void *dStorage, const Rect *boundsRect, char *title, Boolean visible, short procID, WindowPtr behind, Boolean goAwayFlag, long refCon, Handle items)
  98. {
  99.     DialogPtr dp = NewColorDialog(dStorage,boundsRect,c2pstr(title),visible,procID,behind,goAwayFlag,refCon,items);
  100.     p2cstr((StringPtr) title);
  101.     return dp;
  102. }
  103.  
  104.  
  105. void paramtext(char *param0, char *param1, char *param2, char *param3)
  106. {
  107.     ParamText(c2pstr(param0),c2pstr(param1),c2pstr(param2),c2pstr(param3));
  108.     p2cstr((StringPtr) param0);p2cstr((StringPtr) param1);
  109.     p2cstr((StringPtr) param2);p2cstr((StringPtr) param3);
  110. }
  111.  
  112. void getdialogitemtext(Handle item, char *text)
  113. {
  114.     GetDialogItemText(item, (StringPtr) text);
  115.     p2cstr((StringPtr) text);
  116. }
  117.  
  118. void setdialogitemtext(Handle item, char *text)
  119. {
  120.     SetDialogItemText(item,c2pstr(text));
  121.     p2cstr((StringPtr) text);
  122. }
  123.  
  124. short finddialogitem(DialogPtr theDialog, Point *thePt)
  125. {
  126.     return FindDialogItem(theDialog, *thePt);
  127. }
  128.  
  129. OSErr getvinfo(short drvNum, char *volName, short *vRefNum, long *freeBytes)
  130. {
  131.     OSErr err = GetVInfo(drvNum, (StringPtr) volName, vRefNum, freeBytes);
  132.     p2cstr((StringPtr) volName);
  133.     return err;
  134. }
  135.  
  136. OSErr getvol(char *volName, short *vRefNum)
  137. {
  138.     OSErr err = GetVol((StringPtr) volName,vRefNum);
  139.     p2cstr((StringPtr) volName);
  140.     return err;
  141. }
  142.  
  143.  
  144. OSErr setvol(char *volName, short vRefNum)
  145. {
  146.     OSErr err = SetVol(c2pstr(volName),vRefNum);
  147.     p2cstr((StringPtr) volName);
  148.     return err;
  149. }
  150.  
  151. OSErr flushvol(char *volName, short vRefNum)
  152. {
  153.     OSErr err = FlushVol(c2pstr(volName),vRefNum);
  154.     p2cstr((StringPtr) volName);
  155.     return err;
  156. }
  157.  
  158. OSErr unmountvol(char *volName, short vRefNum)
  159. {
  160.     OSErr err = UnmountVol(c2pstr(volName),vRefNum);
  161.     p2cstr((StringPtr) volName);
  162.     return err;
  163. }
  164.  
  165. OSErr eject(char *volName, short vRefNum)
  166. {
  167.     OSErr err = Eject(c2pstr(volName),vRefNum);
  168.     p2cstr((StringPtr) volName);
  169.     return err;
  170. }
  171.  
  172. OSErr create(char *fileName, short vRefNum, OSType creator, OSType fileType)
  173. {
  174.     OSErr err = Create(c2pstr(fileName), vRefNum, creator, fileType);
  175.     p2cstr((StringPtr) fileName);
  176.     return err;
  177. }
  178.  
  179. OSErr fsopen(char *fileName, short vRefNum, short *refNum)
  180. {
  181.     OSErr err = FSOpen(c2pstr(fileName),vRefNum,refNum);
  182.     p2cstr((StringPtr) fileName);
  183.     return err;
  184. }
  185.  
  186. OSErr openrf(char *fileName, short vRefNum, short *refNum)
  187. {
  188.     OSErr err =OpenRF(c2pstr(fileName), vRefNum, refNum);
  189.     p2cstr((StringPtr) fileName);
  190.     return err;
  191. }
  192.  
  193. OSErr getfinfo(char *fileName, short vRefNum, FInfo *fndrInfo)
  194. {
  195.     OSErr err = GetFInfo(c2pstr(fileName),vRefNum,fndrInfo);
  196.     p2cstr((StringPtr) fileName);
  197.     return err;
  198. }
  199.  
  200. OSErr setfinfo(char *fileName, short vRefNum, FInfo *fndrInfo)
  201. {
  202.     OSErr err = SetFInfo(c2pstr(fileName), vRefNum, fndrInfo);
  203.     p2cstr((StringPtr) fileName);
  204.     return err;
  205. }
  206.  
  207. OSErr setflock(char *fileName, short vRefNum)
  208. {
  209.     OSErr err = SetFLock(c2pstr(fileName),vRefNum);
  210.     p2cstr((StringPtr) fileName);
  211.     return err;
  212. }
  213.  
  214. OSErr rstflock(char *fileName, short vRefNum)
  215. {
  216.     OSErr err = RstFLock(c2pstr(fileName),vRefNum);
  217.     p2cstr((StringPtr) fileName);
  218.     return err;
  219. }
  220.  
  221. void getfontname(short familyID, char *theName)
  222. {
  223.     GetFontName(familyID,(unsigned char *)theName);
  224.     p2cstr((StringPtr) theName);
  225. }
  226.  
  227. void getfnum(char *theName, short *familyID)
  228. {
  229.     GetFNum(c2pstr(theName),familyID);
  230.     p2cstr((StringPtr) theName);
  231. }
  232.  
  233. void laddtocell(Ptr dataPtr, short dataLen, Cell *theCell, ListHandle lHandle)
  234. {
  235.     LAddToCell(dataPtr,dataLen, *theCell,lHandle);
  236. }
  237.  
  238. void lcellsize(Point *cSize, ListHandle lHandle)
  239. {
  240.     LCellSize(*cSize, lHandle);
  241. }
  242.  
  243. Boolean lclick(Point *pt, short modifiers, ListHandle lHandle)
  244. {
  245.     return LClick(*pt,modifiers, lHandle);
  246. }
  247.  
  248. void lclrcell(Cell *theCell, ListHandle lHandle)
  249. {
  250.     LClrCell(*theCell, lHandle);
  251. }
  252.  
  253. void ldraw(Cell *theCell, ListHandle lHandle)
  254. {
  255.     LDraw(*theCell, lHandle);
  256. }
  257.  
  258. void lgetcelldatalocation(short *offset, short *len, Cell *theCell, ListHandle lHandle)
  259. {
  260.     LGetCellDataLocation(offset, len,*theCell, lHandle);
  261. }
  262.  
  263. ListHandle lnew(Rect *rView, Rect *dataBounds, Point *cSize, short theProc, WindowPtr theWindow, Boolean drawIt, Boolean hasGrow, Boolean scrollHoriz, Boolean scrollVert)
  264. {
  265.     return LNew(rView,dataBounds,*cSize, theProc, theWindow, drawIt,hasGrow, scrollHoriz, scrollVert);
  266. }
  267.  
  268. void lrect(Rect *cellRect, Cell *theCell, ListHandle lHandle)
  269. {
  270.     LRect(cellRect, *theCell, lHandle);
  271. }
  272.  
  273. void lsetcell(Ptr dataPtr, short dataLen, Cell *theCell, ListHandle lHandle)
  274. {
  275.     LSetCell(dataPtr, dataLen,*theCell, lHandle);
  276. }
  277.  
  278. void lsetselect(Boolean setIt, Cell *theCell, ListHandle lHandle)
  279. {
  280.     LSetSelect(setIt, *theCell, lHandle);
  281. }
  282.  
  283. MenuHandle newmenu(short menuID, char *menuTitle)
  284. {
  285.     MenuHandle h = NewMenu(menuID,c2pstr(menuTitle));
  286.     p2cstr((StringPtr) menuTitle);
  287.     return h;
  288. }
  289.  
  290. void appendmenu(MenuHandle menu, char *data)
  291. {
  292.     AppendMenu(menu,c2pstr(data));
  293.     p2cstr((StringPtr) data);
  294. }
  295.  
  296. long menuselect(Point *startPt)
  297. {
  298.     return MenuSelect(*startPt);
  299. }
  300.  
  301. void setmenuitemtext(MenuHandle menu, short item, char *itemString)
  302. {
  303.     SetMenuItemText(menu,item,c2pstr(itemString));
  304.     p2cstr((StringPtr) itemString);
  305. }
  306.  
  307. void getmenuitemtext(MenuHandle menu, short item, char *itemString)
  308. {
  309.     GetMenuItemText(menu, item, (StringPtr) itemString);
  310.     p2cstr((StringPtr) itemString);
  311. }
  312.  
  313. void insertmenuitem(MenuHandle theMenu, char *itemString, short afterItem)
  314. {
  315.     InsertMenuItem(theMenu, c2pstr(itemString), afterItem);
  316.     p2cstr((StringPtr) itemString);
  317. }
  318.  
  319. short relstring(char *str1, char *str2, Boolean caseSens, Boolean diacSens)
  320. {
  321.     short s = RelString(c2pstr(str1), c2pstr(str2), caseSens, diacSens);
  322.     p2cstr((StringPtr) str1); p2cstr((StringPtr) str2);
  323.     return s;
  324. }
  325.  
  326. void upperstring(char *theString, Boolean diacSens)
  327. {
  328.     UpperString(c2pstr(theString),diacSens);
  329.     p2cstr((StringPtr) theString);
  330. }
  331.  
  332. short iucompstring(char *aStr, char *bStr)
  333. {
  334.     short s = IUCompString(c2pstr(aStr), c2pstr(bStr));
  335.     
  336.     p2cstr((StringPtr) aStr); p2cstr((StringPtr) bStr);
  337.     return s;
  338. }
  339.  
  340. short iuequalstring(char *aStr, char *bStr)
  341. {
  342.     short s = IUEqualString(c2pstr(aStr), c2pstr(bStr));
  343.     
  344.     p2cstr((StringPtr) aStr); p2cstr((StringPtr) bStr);
  345.     return s;
  346. }
  347.  
  348. short iucomppstring(char *aStr, char *bStr, Handle intlHandle)
  349. {
  350.     short s = IUCompPString(c2pstr(aStr), c2pstr(bStr), intlHandle);
  351.     p2cstr((StringPtr) aStr); p2cstr((StringPtr) bStr);
  352.     return s;
  353. }
  354.  
  355. short iuequalpstring(char *aStr, char *bStr, Handle intlHandle)
  356. {
  357.     short s = IUEqualPString(c2pstr(aStr), c2pstr(bStr),intlHandle);
  358.     p2cstr((StringPtr) aStr); p2cstr((StringPtr) bStr);
  359.     return s;
  360. }    
  361.  
  362.  
  363. short iustringorder(char *aStr, char *bStr, ScriptCode aScript, ScriptCode bScript, LangCode aLang, LangCode bLang)
  364. {
  365.     short s = IUStringOrder(c2pstr(aStr), c2pstr(bStr), aScript, bScript, aLang, bLang);
  366.     p2cstr((StringPtr) aStr); p2cstr((StringPtr) bStr);
  367.     return s;
  368. }
  369.  
  370. void stringtonum(char *theString, long *theNum)
  371. {
  372.     StringToNum(c2pstr(theString), theNum);
  373.     p2cstr((StringPtr) theString);
  374. }
  375.  
  376. void numtostring(long theNum, char *theString)
  377. {
  378.     NumToString(theNum, c2pstr(theString));
  379.     p2cstr((StringPtr) theString);
  380. }
  381.  
  382. OSErr dibadmount(Point *where, long evtMessage)
  383. {
  384.     return DIBadMount(*where, evtMessage);
  385. }
  386.  
  387. OSErr dizero(short drvnum, char *volName)
  388. {
  389.     OSErr err = DIZero(drvnum, c2pstr(volName));
  390.     p2cstr((StringPtr) volName);
  391.     return err;
  392. }
  393.  
  394. void sfputfile(Point *where, char *prompt, char *origName, DlgHookUPP dlgHook, SFReply *reply)
  395. {
  396.     SFPutFile(*where, c2pstr(prompt), c2pstr(origName), dlgHook, reply);
  397.     p2cstr((StringPtr) prompt); p2cstr((StringPtr) origName);
  398. }
  399.  
  400. void sfpputfile(Point *where, char *prompt, char *origName, DlgHookUPP dlgHook, SFReply *reply, short dlgID, ModalFilterUPP filterProc)
  401. {
  402.     SFPPutFile(*where, c2pstr(prompt), c2pstr(origName),dlgHook,reply,dlgID,filterProc);
  403.     p2cstr((StringPtr) prompt); p2cstr((StringPtr) origName);
  404. }
  405.  
  406. void sfgetfile(Point *where, char *prompt, FileFilterUPP fileFilter, short numTypes, SFTypeList typeList, DlgHookUPP dlgHook, SFReply *reply)
  407. {
  408.     SFGetFile(*where, c2pstr(prompt),fileFilter,numTypes,typeList, dlgHook, reply);
  409.     p2cstr((StringPtr) prompt);
  410. }
  411.  
  412. void sfpgetfile(Point *where, char *prompt, FileFilterUPP fileFilter, short numTypes, SFTypeList typeList, DlgHookUPP dlgHook, SFReply *reply, short dlgID, ModalFilterUPP filterProc)
  413. {
  414.     SFPGetFile(*where, c2pstr(prompt),fileFilter, numTypes, typeList,dlgHook, reply, dlgID, filterProc);
  415.     p2cstr((StringPtr) prompt);
  416. }
  417.  
  418. void iudatestring(long dateTime, DateForm longFlag, char *result)
  419. {
  420.     IUDateString(dateTime, longFlag,(StringPtr) result);
  421.     p2cstr((StringPtr) result);
  422. }
  423.  
  424. void iutimestring(long dateTime, Boolean wantSeconds, char *result)
  425. {
  426.     IUTimeString(dateTime, wantSeconds, (StringPtr) result);
  427.     p2cstr((StringPtr) result);
  428. }
  429.  
  430. void iudatepstring(long dateTime, DateForm longFlag, char *result, Handle intlHandle)
  431. {
  432.     IUDatePString(dateTime,longFlag, (StringPtr) result, intlHandle);
  433.     p2cstr((StringPtr) result);
  434. }
  435.  
  436. void iutimepstring(long dateTime, Boolean wantSeconds, char *result, Handle intlHandle)
  437. {
  438.     IUTimePString(dateTime, wantSeconds, (StringPtr) result, intlHandle);
  439.     p2cstr((StringPtr) result);
  440. }
  441.  
  442. void iuldatestring(LongDateTime *dateTime, DateForm longFlag, char *result, Handle intlHandle)
  443. {
  444.     IULDateString(dateTime, longFlag, (StringPtr) result, intlHandle);
  445.     p2cstr((StringPtr) result);
  446. }
  447.  
  448. void iultimestring(LongDateTime *dateTime, Boolean wantSeconds, char *result, Handle intlHandle)
  449. {
  450.     IULTimeString(dateTime, wantSeconds, (StringPtr) result, intlHandle);
  451.     p2cstr((StringPtr) result);
  452. }
  453.  
  454. void drawstring(char *s)
  455. {
  456.     DrawString(c2pstr(s));
  457.     p2cstr((StringPtr) s);
  458. }
  459.  
  460. short stringwidth(char *s)
  461. {
  462.     short r = StringWidth(c2pstr(s));
  463.     
  464.     p2cstr((StringPtr) s);
  465.     return r;
  466. }
  467.  
  468. Boolean ptinrect(Point *pt, const Rect *r)
  469. {
  470.     return PtInRect(*pt, r);
  471. }
  472.  
  473. void pt2rect(Point *pt1, Point *pt2, const Rect *destRect)
  474. {
  475.     Pt2Rect(*pt1, *pt2, (Rect *)destRect);
  476. }
  477.  
  478. void pttoangle(const Rect *r, Point *pt, short *angle)
  479. {
  480.     PtToAngle(r, *pt, angle);
  481. }
  482.  
  483. Boolean ptinrgn(Point *pt, RgnHandle rgn)
  484. {
  485.     return PtInRgn(*pt, rgn);
  486. }
  487.  
  488. void addpt(Point *src, Point *dst)
  489. {
  490.     AddPt(*src, dst);
  491. }
  492.  
  493. void subpt(Point *src, Point *dst)
  494. {
  495.     SubPt(*src, dst);
  496. }
  497.  
  498. Boolean equalpt(Point *pt1, Point *pt2)
  499. {
  500.     return EqualPt(*pt1,*pt2);
  501. }
  502.  
  503. void stuffhex(Ptr thingPtr, char *s)
  504. {
  505.     StuffHex(thingPtr, c2pstr(s));
  506.     p2cstr((StringPtr) s);
  507. }
  508.  
  509. void stdtext(short count, const void *textAddr, Point *numer, Point *denom)
  510. {
  511.     StdText(count, textAddr, *numer, *denom);
  512. }
  513.  
  514. void stdline(Point *newPt)
  515. {
  516.     StdLine(*newPt);
  517. }
  518.  
  519. void createresfile(char *fileName)
  520. {
  521.     CreateResFile(c2pstr(fileName));
  522.     p2cstr((StringPtr) fileName);
  523. }
  524.  
  525. short openresfile(char *fileName)
  526. {
  527.     short s =  OpenResFile(c2pstr(fileName));
  528.     
  529.     p2cstr((StringPtr) fileName);
  530.     return s;
  531. }
  532.  
  533. short openrfperm(char *fileName, short vRefNum, char permission)
  534. {
  535.     short s = OpenRFPerm(c2pstr(fileName), vRefNum, permission);
  536.     
  537.     p2cstr((StringPtr) fileName);
  538.     return s;
  539. }
  540.  
  541. Handle getnamedresource(ResType theType, char *name)
  542. {
  543.     Handle h = GetNamedResource(theType, c2pstr(name));
  544.     
  545.     p2cstr((StringPtr) name);
  546.     return h;
  547. }
  548.  
  549. Handle get1namedresource(ResType theType, char *name)
  550. {
  551.     Handle h = Get1NamedResource(theType, c2pstr(name));
  552.     p2cstr((StringPtr) name);
  553.     return h;
  554. }
  555.  
  556. void getresinfo(Handle theResource, short *theID, ResType *theType, char *name)
  557. {
  558.     GetResInfo(theResource,theID, theType, c2pstr(name));
  559.     p2cstr((StringPtr) name);
  560. }
  561.  
  562. void setresinfo(Handle theResource, short theID, char *name)
  563. {
  564.     SetResInfo(theResource,theID,c2pstr(name));
  565.     p2cstr((StringPtr) name);
  566. }
  567.  
  568. void addresource(Handle theResource, ResType theType, short theID, char *name)
  569. {
  570.     AddResource(theResource, theType, theID, c2pstr(name));
  571.     p2cstr((StringPtr) name);
  572. }
  573.  
  574. void teclick(Point *pt, Boolean fExtend, TEHandle h)
  575. {
  576.     TEClick(*pt, fExtend, h);
  577. }
  578.  
  579. void getindstring(char *theString, short strListID, short index)
  580. {
  581.     GetIndString((unsigned char *)theString, strListID, index);
  582.     p2cstr((StringPtr) theString);
  583. }
  584.  
  585. StringHandle newstring(char *theString)
  586. {
  587.     StringHandle h = NewString(c2pstr(theString));
  588.     p2cstr((StringPtr) theString);
  589.     return h;
  590. }
  591.  
  592. void setstring(StringHandle theString, char *strNew)
  593. {
  594.     SetString(theString,c2pstr(strNew));
  595.     p2cstr((StringPtr) strNew);
  596. }
  597.  
  598. void shieldcursor(const Rect *shieldRect, Point *offsetPt)
  599. {
  600.     ShieldCursor(shieldRect,*offsetPt);
  601. }
  602.  
  603. long deltapoint(Point *ptA, Point *ptB)
  604. {
  605.     return DeltaPoint(*ptA, *ptB);
  606. }
  607.     
  608. WindowPtr newwindow(void *wStorage, const Rect *boundsRect, char *title, Boolean visible, short theProc, WindowPtr behind, Boolean goAwayFlag, long refCon)
  609. {
  610.     WindowPtr wp = NewWindow(wStorage, boundsRect, c2pstr(title), visible, theProc,behind, goAwayFlag, refCon);
  611.     p2cstr((StringPtr) title);
  612.     return wp;
  613. }
  614.  
  615. WindowPtr newcwindow(void *wStorage, const Rect *boundsRect, char *title, Boolean visible, short procID, WindowPtr behind, Boolean goAwayFlag, long refCon)
  616. {
  617.     WindowPtr wp = NewCWindow(wStorage, boundsRect, c2pstr(title), visible, procID, behind, goAwayFlag, refCon);
  618.     p2cstr((StringPtr) title);
  619.     return wp;
  620. }
  621.  
  622. void setwtitle(WindowPtr theWindow, char *title)
  623. {
  624.     SetWTitle(theWindow, c2pstr(title));
  625.     p2cstr((StringPtr) title);
  626. }
  627.  
  628. void getwtitle(WindowPtr theWindow, char *title)
  629. {
  630.     GetWTitle(theWindow, (StringPtr)  title);
  631.     p2cstr((StringPtr) title);
  632. }
  633.  
  634. short findwindow(Point *thePoint, WindowPtr *theWindow)
  635. {
  636.     return FindWindow(*thePoint,theWindow);
  637. }
  638.  
  639. Boolean trackgoaway(WindowPtr theWindow, Point *thePt)
  640. {
  641.     return TrackGoAway(theWindow,*thePt);
  642. }
  643.  
  644. void dragwindow(WindowPtr theWindow, Point *startPt, const Rect *boundsRect)
  645. {
  646.     DragWindow(theWindow, *startPt, boundsRect);
  647. }
  648.  
  649. long growwindow(WindowPtr theWindow, Point *startPt, const Rect *bBox)
  650. {
  651.     return GrowWindow(theWindow, *startPt, bBox);
  652. }
  653.  
  654. long pinrect(const Rect *theRect, Point *thePt)
  655. {
  656.     return PinRect(theRect, *thePt);
  657. }
  658.  
  659. long draggrayrgn(RgnHandle theRgn, Point *startPt, const Rect *boundsRect, const Rect *slopRect, short axis, DragGrayRgnUPP actionProc)
  660. {
  661.     return DragGrayRgn(theRgn, *startPt, boundsRect, slopRect, axis, actionProc);
  662. }
  663.  
  664. Boolean trackbox(WindowPtr theWindow, Point *thePt, short partCode)
  665. {
  666.     return TrackBox(theWindow, *thePt, partCode);
  667. }
  668.  
  669. void getappparms(char *apName, short *apRefNum, Handle *apParam)
  670. {
  671.     GetAppParms(c2pstr(apName), apRefNum, apParam);
  672.     p2cstr((StringPtr)apName);
  673. }
  674.  
  675. #pragma pointers_in_A0
  676.